﻿

#include <iostream>
#include <string>
using namespace std;

namespace yyp
{
	int a = 11;

	void Test0()
	{
		int a = 22;

		{
			int a = 33;
			cout << a << endl;
		}
	}
}

void Test1()
{
	class Person
	{
	protected:
		string _name = "人"; // 姓名
		string _sex = "男"; // 性别
		int _age = 27; // 年龄
	};

	class Student : public Person
	{
	public:
		int _No = 123; // 学号
	};

	Student s;
	Person* pp = &s;
	Person& rp = s;

	Person p = s;
}

void Test2()
{
	class Person
	{
	protected:
		string _name = "人"; // 姓名
		int _num = 111; // ⾝份证号
	};

	class Student : public Person
	{
	public:
		void Print()
		{
			cout << " 姓名:" << _name << endl;
			cout << " 身份证号:" << Person::_num << endl;

			// 在派生类的成员函数内部，可以直接访问父类的protected成员，因为此时已经在“允许访问”的上下文中了（即派生类的成员函数）
			Person::_num = 123;
			cout << " 身份证号:" << Person::_num << endl;
			
			// 在派生类的成员函数中，this指针的类型是派生类类型，即使将其转换为基类类型的指针，this仍然指向一个派生类对象，这种转换不会改变成员函数的访问权限上下文
			// this指针强转后的访问逻辑相当于通过一个派生类对象来访问基类中的私有（protected）成员，派生类的指针同理
			// 通过派生类的实例化对象是无法访问基类中的私有（protected）成员，这种访问行为本身就是错误的，也是不会被允许的
			// 正确的做法是遵循类的访问控制规则，直接在派生类的成员函数内部访问，不需要进行任何类型转换
			//((Person*)this)->_num = 111; // error: 无法访问 protected 成员(在“Test2::Person”类中声明)
			cout << " 学号:" << _num << endl;
		}

	protected:
		int _num = 999; // 学号
	};

	//Student().Print();
	Student s;
	s.Print();
}

void Test3()
{
	class A
	{
	public:
		void fun()
		{
			cout << "func()" << endl;
		}
	};

	class B : public A
	{
	public:
		void fun(int i)
		{
			cout << "func(int i)" << i << endl;
		}
	};

	
	B b;
	b.fun(10);
	b.A::fun();
}

int main()
{
	//yyp::Test0();
	//Test0();
	//Test1();
	//Test2();
	Test3();

	return 0;
}